MacAddict 6

home *** CD-ROM | disk | FTP | other *** search

/ MacAddict 6 / MacAddict_006_1997_02.iso / Software Updates / MacsBug 6.5.3 / Previous Version Changes < prev

Wrap

Text File | 1996-02-22 | 102.1 KB | 2,055 lines | [TEXT/MPS ]

========================================== MacsBug Release Notes and Bedtime Tales An ongoing release history for MacsBug 6.5 by Jim Murphy and Dave Lyons ========================================== • 6.5.3 - Released 2/9/96 POWERPC STACK CRAWL ------------------- Two bugs were fixed in Mixed Mode “SC6” stack crawls. The stack crawl would always terminate when it encountered a 68K to PowerPC switch frame. It would also terminate with no output in the PowerPC to PowerPC case if the current routine’s frame hadn’t yet been set up. DISASSEMBLY ----------- When MacsBug is entered because of a crash, it no longer tries to disassemble instructions around the current PC if it is at an invalid address (odd, unmapped, etc.). This means that if a program somehow jumps into hyperspace, MacsBug won’t eat itself alive with another exception. Instead, it will display a helpful message in the PC window area. The “PlayMem” 512-byte scratch area will now disassemble with a name and offsets. The ‘…’ character (Option-;) is now a shortcut for the address in the comment field at the current PC. This is most useful when you want to disassemble at the target of a branch at the current PC. With this shortcut, you no longer have to type the actual address. The “IL”, “IP”, and “ID” commands support a ‘-c’ parameter, which means “current ISA”. For example, “il -c …” (where ‘…’ means branch target effective address) disassembles using the correct disassembler automatically. This feature is best used inside of a macro, and the new standard macro “IT” takes advantage of it (see the Macro section below). POWERPC DISASSEMBLY ------------------- Fixed a bug in the PowerPC disassembler front-end logic which would only let you disassemble code at addresses after the system heap start and below the last byte of contiguous RAM (not logically remapped memory), in PowerPC file mapped space, or in the ROM. Any other location would get you an “unable to access that address” message. Rolled in the latest version of the disassembler. It’s a little smaller, and it fixes a problem where the extended mnemonic “mr.” was incorrectly disassembled as “mr”. The disassembler now calls the full symbol lookup code when performing effective address replacement. This fixes two problems; 1) bls to C++ functions now shows the unmangled name, 2) bls to functions not owned by CFM which contain traceback symbols will correctly find and use the names. 68K DISASSEMBLY --------------- In 68K disassembly, MacsBug no longer says “will set to ones” for the $50FF instruction (it’s an illegal 68K instruction). Added “will trap” and “will not trap” for the various trap instructions. POWERPC EXCEPTIONS ------------------ Taking a PowerPC exception no longer trashes the 68K registers D0, A0 and A1. This meant that as you stepped PowerPC code, some 68K registers were silently changing. MacsBug now tries to protect itself from installing its PowerPC exception handler twice. This fixes the problem on certain Performa 5200/6200 configurations where you couldn’t set breakpoints or step in PowerPC code. SYMBOL LOOKUP ------------- Sped up the PowerPC and 68K embedded symbol lookup when using the Command-: pop-up and when evaluating any name in an expression. Significantly reworked the embedded symbol lookup code to better deal with areas of code that are PowerPC, but aren’t known by CFM (such as accelerated resources). In the past, if code wasn’t known by CFM, it was assumed to be 68K, and the PowerPC traceback code was never given a chance to find symbols. That could give very misleading information since quite often parts of PowerPC tracebacks look like old fixed-length 8-character MacsBug names. Reduced the character space for valid traceback symbols to match embedded 68K symbols. This should remove a number of invalid symbols. When showing what PowerPC fragment an address is within, we now show the byte offset into the fragment. This helps when you’re in VM file mapped space and thus not in a heap block. Rolled in the latest C++ symbol unmangler. It’s way cool, and attempts to make sense out of the varying mangling schemes in the ARM, xlC, MrC, Symantec, and CFront. It does a very good job, too. Refreshing the scrollback area after the Command-: symbols pop-up is dismissed now correctly accounts for a scrolled history buffer and doesn’t redraw the wrong text. REGISTER EVALUATION ------------------- I can’t believe this has been broken for so long (all previous versions of MacsBug 6.5). When running with VM on, the value to which “SP” and “A7” evaluate was the interrupt stack pointer, which is wrong. They now correctly evaluate to the value displayed in the regster area for A7. All 68K Dn and An registers are now valid when in PowerPC code. This means you can now display and change them, regardless of the current instruction set. I could go on about how this took some serious voodoo magic, but it didn’t. BREAKPOINTS ----------- Added support for a low-level PowerPC Debugger trap that will stop on the instruction after the trap, without modifying any registers. This is useful for stopping in arbitrary locations within hand-written assembly code. With this special trap, you don’t have to make a cross-TOC call to the high-level Debugger implementation which destroys the volatile registers. The trap instruction is: #define kPowerPCLowLevelDebuggerTrap 0x7F800008 // tw LT|GT|EQ,r0,r0 This trap instruction behaves much like the high-level Debugger call in that it can be enabled and disabled with the “DX” (Debugger Exchange) command. The “BRM” command (Breakpoint Multiple) works again for the first time in years. It was broken in the first version of MacsBug 6.5. STEPPING -------- Fixed a bug in the mode switching step logic. If you stepped across a PowerPC to 68K boundary with a step count or expression (ie. Step until PC = blah), the 68K code on the other side was disassembled as PowerPC. The instruction set associated with the current PC, which is passed into the disassembler, was synchronized only when a 68K to PowerPC switch occurred. After a step, we now show things of interest that may have changed. Currently MemErr, ResErr, and QDErr are watched. If there’s anything else cool we should watch, let us know. Here’s a sample line of output when the value of ResErr changed when a Step Over was executed: Step (over) 'CODE 0002 08D2' +0274C 00CCFDBC _GetResource ; 00049BAE | A9A0 ••• ResErr changed to #-192 (from #0) For drivers that like to call the Memory Manager, we need to save and restore MemErr around all of the video driver calls in the step code path. This means MemErr won’t get reset to zero as you step. A-TRAP ACTIONS -------------- Fixed A-Trap actions when tracing over a trap to actually work again. For example, if you break on MountVol, and then set an ATB on Read, and then trace over the MountVol, you won’t break on Read even though it’s being called a number of times. This was broken in MacsBug 6.5.2 in an attempt to fix anther bug. Both are now fixed. A-Trap disassembly and breaking has been significantly enhanced to support all variants of each trap word. For example, we now correctly disassemble the trap word 0xA22E as BlockMoveData, and you can now break on it by name. We’d suggest using the new API command to browse the full namespace that MacsBug supports for trap display and breaking. Updated trap selectors for DisplayDispatch, ColorSync 2.0, HFSUtil, FSM, ReleaseFolder, QuickTime and SoundDispatch. API COMMAND ----------- Added a new command, “API”. This command shows anything MacsBug knows about a given trap or trap range. It shows if the trap has selectors, what those selectors are, and if they are implemented in 68K code, PowerPC, or both. It’s way cool, and will show even more info in the future. HEAP DUMPING ------------ The “HD” command (Heap Dump) has new options that can greatly reduce the number of heap blocks you need to examine during debugging. The ‘-s’ and ‘-e’ options allow you to constrain the range of addresses that are dumped within the current heap. The ‘-s’ option lets you specify the starting address, and ‘-e’ lets you specify the ending address. If you use the two options together, ‘-e’ can optionally be used as a byte count. If the end is less than the start, it’s a length. To limit display to blocks of certain sizes, you can use up to two options of the form “,<20”. The possible tests are <, =, >, <=, and >=. For example, “HD RS,>1K,<5K” shows resource blocks with sizes between 1K and 5K. COMMAND LINE ------------ The macro “GG” (clear breaks and Go) no longer gets saved into the command-line history. Made the command line history logic sensitive to case. This is useful such as when you capitalize a case-sensitive CFM symbol incorrectly and then repeat the command. The corrected version now gets saved in the command history. Parameter parsing works much better, because binary ‘-’ (subtraction, not negation) can no longer have a blank before it. This means that commands such as “RD -f 2 -i 3” now work, for example. Previously, it would try to evaluate “2-i”. MACSBUG PREFERENCES FOLDER -------------------------- The “MacsBug Preferences” folder can now be located in the same folder as MacsBug (the System Folder) or within your “Preferences” folder (actually whatever it’s called, we’re international-savvy). You can place your various preferences files within either or both of these folders. As before, up to 32 files will be opened (this is the sum total of both folders, not 32 per folder). DCMDS ----- The PC window now redraws if a dcmd modifies the current PC. Updated the Errors dcmd to match the latest Errors.h header file. I also rewrote it in C because I was bored one night (yes, that bored). Fixed two problems in the Leaks dcmd which could cause it to crash on 68K machines. It now does Mixed Mode stack crawls only if it’s on a PowerPC machine. The PowerPC crawl now validates the back chains as it climbs over switch frames. Updated the display of ISAs to be more consistent with MacsBug. The Gestalt dcmd has been enhanced, and now takes two options. It can be asked to just show one selector as in “Gestalt 'sysa'”, and it can just dump the installed selectors without calling them as in “Gestalt -n”. The RD dcmd has a new option, ‘-o’, which turns on display of resource data offsets. Some labels have been abbreviated to save space. The functionality of the StopIf dcmd is now part of MacsBug as a built-in command. The external implementation was quite lame in that it poked MacsBug’s globals (incorrectly, for the last couple of years). Fixed a problem where the A7 register as passed to dcmds with VM on is the wrong stack. It was always passing the interrupt stack pointer, when it really should be the one shown in the register display area as A7. Universalitized dcmd.h and dcmd.p. All constants are now enums, rather than #defines. The input strings to callbacks that are constant are now declared properly. The files are now wrapped in the standard C++ and structure alignment goo. Added the FSInfo dcmd (by Jim Luther), and made it format 3. It has a new option, ‘-t’, which shows a summary table of all installed external file systems. When warning that you have duplicate dcmds, the compare is now case-insensitive, so we don’t miss any. Updated all of the sample dcmds sample build commands to be current. Included the latest PowerPC dcmds in their own file, “PowerPC dcmds”. MACROS ------ Added MPW SetKey-style key bindings for all extended keyboard function keys. You can define macros that get executed when any of the keys are hit. The macros expected are of the following form (where ‘n’ is the function key from 1 through 15): DoFn DoCmdFn DoOptFn DoCmdOptFn The extended keyboard keys Help, Home, Page Up, Forward-Delete, End, and Page Down are now supported. With Help you can type a command name and then Help, and you’ll get that specific reference section. Help alone gives you the entire help text (pressing Help places a ‘?’ as the first character on the command line and then presses return for you). Added “cw” and “cwp” macros for breaking into the Metrowerks debugger in 68K and PowerPC code, respectively. The size of the buffer in which you can create macros at runtime has been increased from 256 bytes to 1K. The “MC” command (Macro) now wraps output properly, rather than having it extend off of the right side of the screen. Added comments to some common macros, which are now shown if you get help on a macro. Added a macro named “IT” which disassembles the target effective address at the current PC. This is a shortcut for typying “ILP …” or “IL …” (the macro does the right thing and gets the instruction set correct). Added a “TimeTasks” macro for walking though all of the currently pending Time Manager tasks. TEMPLATES --------- Added some new basic types: SECONDS, ATRAPWORD, BINARY8, BINARY16, BINARY32, and OSTYPE. A number of the standard templates were changed to use these new types. The CGrafPort template now references the portPixMap as a PixMap, rather than a handle. The IOREFNUM basic type now displays driver names as well as file names. Duplicate definitions of DCtlEntry and Driver were removed from the standard templates. LOGGING/STDLOG -------------- MacsBug now knows what version of the system it’s running on when you break into it right after it loads. This means log files at boot time will go to the desktop by default (among other internal behaviour changes). The log mechanism has been enhanced to be as robust as it can be, given the runtime MacsBug lives in. We now make sure interrupts are enabled when both printing and logging. We no longer write data to the log file when the file system is busy (as best as we can tell), and you’ll get a warning message if it is. This should clean up a lot of lockups if you NMI with logging on. Writes to the log no longer go into the file system cache. When writing to the log file, we now flush the volume as well as the file. This way all logging actions should stick even if you crash with the file still open. The “StdLog” macro (and any others that use the SET SUSPENDPROMPT feature) no longer randomly starts prompting you to press return again after a dcmd executes. Fixed the “StdLog” macro so it doesn’t change your current TargetZone (the calls to “HX” are now balanced). The “STAT” command now displays the Gestalt ‘sysu’ (System Update version) value if it’s present. MISCELLANEOUS ------------- Help on the Help command works reliably now. Added a new SET option, “SIMPLIFIED”. This allows you to toggle the display of PowerPC extended mnemonics. If MacsBug is running on a PowerPC machine, it now ignores what Gestalt says and records that the ROM is really 4 MB. This means that using the “WH” command (Where) in the last 1 MB of the ROM will say it’s in ROM, because it really is. Previous versions of MacsBug thought ROMs on PowerPC machines were 3 MB (that’s the size of the 68K portion). The U.S. KCHR that we distrbute is now the System 7.x one instead of 6.x. A command of “# ” (pound sign followed by a blank) means the rest of the line is a comment. This is useful in macros. If we have a ‘#’ in front of a decimal constant and fail to convert it, that’s an immediate syntax error. We no longer incorrectly proceed to look it up as a symbol. The machine names list had an incorrect ‘mach’ value for the 8100/100. Blank Return just scrolls display by one line, so you can now insert blank lines into the history if you wish. The internal processor cache range flush routine now goes to extra efforts to make sure that the cache flushing A-Trap it calls is implemented before calling it. This makes “SM” (Set Memory) and breakpoints work at boot on older Mac IIs. The 6100/7100/8100 sound driver bus error fix now only runs on 7.5, 7.5.1, and 7.5.2. The real bug has been fixed in System 7.5.3. The “CS” command (Checksum) now shows the checksum value. The trivially simple 68K assembly code to do the checksum is: ***************************************************************************************** ; ; pascal long ComputeChecksum(Ptr lowAddr, Ptr highAddr); ; ; Calculate checksum over specified address range. Checksum is calculated by summing ; one byte at a time into a long word starting from the low address, and rotating ; left 1 bit (high order bit rotates to low order bit) after each byte is added. ; ComputeChecksum FUNC EXPORT move.l (sp)+, d0 ; Return address movea.l (sp)+, a1 ; High address movea.l (sp)+, a0 ; Low address move.l d0, -(sp) ; Restore return address to stack. moveq #0, d0 ; Sum bytes in long word, rotating left one bit after each byte is added. @loop add.b (a0)+, d0 rol.l #1, d0 cmpa.l a1, a0 ble.s @loop move.l d0, 4(sp) rts ENDF • 6.5.2 - Released 7/26/95 | •• NOTE •• - MacsBug 6.5.1 was never released, so please be sure to read what changed in | •• NOTE •• - that version in the section below. MIXED MODE STEPPING ------------------- You can now step across all Mixed Mode transitions. This means that when you come up to a MixedModeMagic trap, stepping once more lands on the first instruction on the other side, whether it's 68K or PowerPC. Similarly, when you're stepping through PowerPC code that calls the functions CallUniversalProc or CallOSTrapUniversalProc, you will automatically land on the other side of the call. When returning from a 68K routine to PowerPC code or vice-versa, stepping the return instruction will take you back to the caller, whether it's 68K or PowerPC. There should be no instances where stepping takes you into Mixed Mode itself (so if you're debugging Mixed Mode, use another debugger). Mixed Mode stepping works equally well with accelerated ("fat") resources. If your 68K code loads and calls into a fat resource, you can simply step right into it. NMIs IN NATIVE CODE ------------------- Using the NMI key sequence, you can now interrupt native code execution, and will land on the PowerPC instruction you interrupted. However, due to reentracy concerns, you cannot interrupt in the middle of Mixed Mode execution, you'll land in 68K code like you used to do with older versions of MacsBug. BUS ERROR CATCHING ON POWERPC ----------------------------- Bus error handling on the first-generation PowerPC machines (6100/7100/8100) now works. This really wasn't a bug in MacsBug, but I fixed it anyway. The problem was that the sound-in component trashes the bus error vector when it is loaded (this is the case in 7.5 and 7.5.1). MacsBug now takes care of the component load through a magical patch, and fixes up the bus error vector if it becomes damaged. See, MacsBug really is system software. POWERPC STACK CRAWL ------------------- Fixed the infinite loop bug in the “SC” command when walking back over PowerPC->68K switch frames (mentioned in the 6.5.1 release notes). POWERPC DEBUGGER/DEBUGSTR CALLS ------------------------------- When you execute a Debugger or DebugStr in native code, you should no longer land in the implementation (in InterfaceLib at present), you'll be in your own code right after the branch to the library where they live. POWERPC STEPPING ---------------- Stepping or tracing with a count now works in PowerPC code. POWERPC REGISTER DISPLAY ------------------------ When on a PowerPC machine, we now show the current interrupt mask in place of the Memory Manager mode in the left sidebar area (you're always in 32-bit mode). This is shown (and is correct) when in both 68K or PowerPC code. The current interrupt mask is shown in the PowerPC register set when the “TD” command is used. Changed “TF” command to show the exponent and sign of each FPR as one component. REGISTER ASSIGNMENT ------------------- You can now set and get A5 when in both 68K and PowerPC code. For the moment, this is the only 68K register you can get to since it's the most useful. This means that macros like “thecport” work regardless of the current instruction set. The 68020-040 register formerly known as “DFC” (Data Function Code) must now be called “RDFC” so it's no longer hex (nobody cares about this register anyway). COMMANDS FIXED/ADDED -------------------- Added a new command "STAT" and incorporated it into the StdLog macro. It shows lots of useful information you can see on the screen, but have never had an easy way of getting into the log (at least not very concisely). For instance, it identifies the names of all shipping machines that have unique box flag values, shows used stack space, max-used stack space when available, and ResErr/MemErr when they are nonzero. The “EA” (Exit to Application) and “ES” (Exit to Shell) commands now work when you're in PowerPC code. The “IR” (Instruction list to Return) command now works in PowerPC code with no address. “IRP” (Instruction list to Return PowerPC) command has been added. “GTP” (Go Till in PowerPC code) command has been added. Restarting (RS/RB) now works in a general way on PCI-based machines. It used to need a box flag table, which was a work-around for early developmental ROMs without a reasonable Gestalt selector to identify that the machine needed a hard reset to restart. The “DMA” (Display Memory ASCII) command now honors the DITTO mode. WH COMMAND ---------- When displaying the CFM library an address lives in, we now display the executable and writable status of the section the address is in (if any). If an address is in low memory, we now say so (instead of saying it's in RAM but not in a know heap). A-TRAP RECORDING ON QUADRA/PERFORMA 63x AND POWERBOOK 150 --------------------------------------------------------- It works, and doesn't make your machine crash. I really don't want to tell you why 'cause it would make a great puzzle page. A-TRAP ACTIONS -------------- A-Trap tracing and recording no longer mask trap values into the A000-A0FF and A800-ABFF range when displaying them, all bits are shown as-is when the trap was executed. A-Trap trace now shows the name of the real call that was made if the trap is selector-based (dispatched), rather than the trap. This means you'll see traces with information such as “SameProcess” instead of “OSDispatch”, which is much more useful. A-Trap recording and tracing now identifies Enqueue and Dequeue as stack-based traps rather than register-based (they aren't). A-Trap break, trace, and step-spy logic has been fixed so you can now have combinations of them pending at the same time that actually work. In the past you couldn't have a trace and a break work at the same time, the first one that was activated got precedence. This means you can now have multiple trace ranges and they'll work as well. Fixed the long-standing (since November 24, 1992, to be exact) bug where you'd land near a TRAP #$D inside MacsBug if you stepped over an A-Trap that had a break action set on it. Setting an A-Trap break while in PowerPC code works (I was stupid and failed to install the A-Trap dispatcher patch). 68K DISASSEMBLY --------------- When disassembling a MixedModeMagic trap (0xAAFE) that's at the current 68K PC, we now show the address that you'll land if you step across the mode transition, as well as the destination instruction set. When disassembling an A-Trap instruction, the comment field now contains the implementation address of the trap, rather then the trap word. It's already shown off to the right anyway. POWERPC DISASSEMBLY ------------------- When disassembling PowerPC code that uses an offset off of R0, we now look up macros for that address. For example, instead of getting this disassembly: lwz r3, 0x064F(0) you'll get: lwz r3, JFlushCache(r0) Throughout PowerPC disassembly all fields are now shown in hex instead of decimal. The symbol lookup code now lets tracebacks win if they're at the same address as a previously found CFM export. This lets the disassembler munch the embedded data making the disassembly look nicer (and smaller). The glue sniffer can now identify Microsoft-style cross-TOC glue. SYMBOL LOOKUP ------------- I drastically sped up CFM/traceback lookups over 6.5.1 so MacsBug is usable again. Optimized embedded 68K symbol lookup so it's about 10% faster. MISCELLANEOUS ------------- Fixed all instances (hopefully) where switching ISAs while in MacsBug wouldn't cause the register names to be erased and redrawn. My internal concept of current and previous ISA was a bit loopy. The syntax error display for all non-repeating commands has been fixed (br, etc.) You'll no longer see the entire help text as one garbled mess. Yeah, it confused me too. The “explain significance of” feature shows nicer output for slightly-negative numbers (0 to -16M). The display of “is a bad pointer” only yells about odd pointers on 68000s. Made internal commands override dcmds of the same name. You can specify a dcmd (only) by putting a "∂" in front of the name (and it should work for Help, too, as in "?∂cfm"). Allow "≠" for not-equal (Dave did it, I'll never remember it). Moved the typographical quotes up by one pixel (to make Greg Robbins happy). BUILT-IN DEBUGGER PREFS ----------------------- Fixed Get1xType and Get1xResource to be Get1IndType and Get1IndResource (we've added two macros to let you still type Get1xType and Get1xResource if you really want to). Replaced PPCJump macro with a more general one. PPCJumpA is now the old "branch absolute" version. • 6.5.1 - Built 6/2/95 - never released due to serious symbol lookup bug POWERPC SYMBOL LOOKUP --------------------- The PowerPC symbol lookup mechanism has been reworked so that exported CFM symbols and embedded traceback symbols get along much better. If you have a PowerPC container that has both exports and tracebacks, CFM symbols no longer always win, the best (closest) symbol of either type will be returned. When disassembling arbitrary PowerPC code (you know, when you're bored and still at work at 4:00 am), MacsBug now sniffs through cross-TOC glue code to provide meaningful symbols. So, instead of seeing something like this: bl $+0x76F8 ; 0x00007848 | 480076F9 lwz RTOC,0x0014(SP) | 80410014 You'll see something like this: bl NewPtrSysClear ; 0x00007848 | 480076F9 lwz RTOC,0x0014(SP) | 80410014 Currently this works with applications and any import libraries that are pulled in by CFM as part of a closure, such as InterfaceLib, MathLib, or DragLib, for example. If you load and prepare a fragment yourself, or use accelerated resources, MacsBug cannot identify the symbols in those fragments. However, this may change in the future. EMBEDDED SYMBOLS ---------------- When walking a heap to search for embedded symbols, either by name or address, the code that determined whether a heap block should be searched was rather lame. It rejected all non-relocatable blocks, but was quite happy to search free blocks. This meant it wasted a lot time looking for symbols where you wouldn't have any, and it probably missed others that you did have. One place where you'll notice this is when you “HX” to the System heap and use symbols pop-up window. You'll probably see lots of new names that have been lurking in non-relocatable blocks. Please note that if you evaluate a symbol in the System heap (by typing its name on the command- line), the time to search can take significantly longer than in previous versions. This is simply due to searching more blocks. In future versions the performance will be addressed. POWERPC EMBEDDED SYMBOLS ------------------------ You can now use the names of traceback symbols in expressions just as you have been able to with embedded 68K MacsBug names for, well, ever. As with 68K names, only the TargetZone as specified with the “HX” command will be searched. SYMBOLS POP-UP WINDOW --------------------- The utility and size of the symbols pop-up window has been increased. The width is now relative to the width of the MacsBug display area, so it's larger. This should provide a bit more room for really long unmangled C++ symbols. MacsBug now locates and displays more types of symbols in the pop-up. It can now find 68K embedded symbols, PowerPC traceback embedded symbols, and CFM code exports. Each symbol is now classified with a symbol/instruction set designator at the right side of each line displayed. The symbol types you should see, as well as their meanings, are as follows: 68K MBug - Traditional 68K MacsBug embedded symbol PPC TBT - PowerPC/AIX-style traceback table embedded symbol PPC CFM - PowerPC Code Fragment Manager exported TVector symbol POWERPC DEBUGGING ----------------- A number of bugs involving PowerPC debugging have been fixed. These are: • You can now hit a breakpoint and Go from it. Previously, you had to step once before allowing execution to continue or you'd crash. • You can now step over a subroutine call such as “bl” when it has a breakpoint set on it. • When stepping over a conditional subroutine call such as “beqlr” when the branch is not going to be taken, MacsBug no longer returns to running your program at full-speed. • Expressions and counts on breakpoints now actually work. POWERPC EXCEPTION PROCESSING ---------------------------- Previous versions of MacsBug would handle more or less every exception that was passed to it. In certain situation this is a reasonably unfriendly thing for it to be doing, and can really annoy the user. So, in an effort to be nicer to users as well as high-level debuggers, MacsBug now only catches exceptions if nobody else chose to do so. This means that all PowerPC unmapped memory exceptions that take place within the Modern Memory Manager due to broken applications will once again be masked from the user's view. However, if you would prefer to be notified about every exception, there are two ways you can re-enable previous behavior. At runtime, you can use the new “SET AUTOGP” command. When AUTOGP is enabled (the default), all exceptions are automatically forwarded to anyone who wants them. When it's off, MacsBug will catch everything that comes its way. If you would like to permanently set the behaviour, you can edit the 'mxpr' resource within MacsBug using ResEdit. By setting the “Don't auto propagate PowerPC xcpts” field, you can specify the initial AUTOGP value. When you're executing PowerPC code and somehow get your PC pointing into unmapped memory, MacsBug handles this a bit better. It used to take a 68K bus error in the middle of the PowerPC bus error, and it would show the entirely wrong register set. It's not perfect (yet) but at least it will be a lot less confusing if this ever happens to you. HEAP ZONES ---------- Throughout MacsBug, application heaps are now called out with the name of their corresponding application. Only the heap that an application was launched into is named, any other private heaps that an application may have created are not named. Heap names are used in such places as the “HX” (Heap Exchange), “HZ” (Heap Zones), “HT” (Heap Total), and “WH” (Where) commands, among others. The “HZ” command has been enhanced to display the size of each heap in K. The values are shown on the left side of the display before the heap addresses. HEAP CHECK COMMAND ------------------ The “HC” (Heap Check) command now has an option. Rather than just checking the TargetZone, you can now check all heaps simultaneously with the “ALL” option. The set of heaps that is checked is that same that are identified with the “HZ” command. If the command detects any of the heaps to be corrupt, it will not terminate the overall check, it will continue on with the next heap (if any). HEAP CORRUPTION DETECTION ------------------------- Whenever MacsBug walks a heap, either explicitly when you dump a heap, or implicitly when looking up a symbol, each heap block is checked for possible corruption. However, due to a bug introduced when it was rewritten in C, the three tests performed on each block all had to fail simultaneously for a block to be marked as bad. Since two of the three were mutually-exclusive, MacsBug could never detect any block as being bad. This strikes us as less than useful, so it's been fixed. Note that this code was not part of the “HC” command, which worked fine, it's only a simple test within the general heap walker mechanism. STACK CRAWL ----------- MacsBug now can walk A6/R1 Mixed Mode stacks with the “SC” command. Consistent with previous behaviour, if it can't find a valid back-chain link, the crawl terminates. A very small number of people have reported that the command occasionally never returns keyboard control. This may have been due to other problems in embedded symbols lookup (which have been fixed and were noted above), but since we could never reproduce the lockup, we're just not sure. If you have any problems with this new feature, please let us know about it as soon as possible. Occasionally, if you and/or your computer got hit with some wiggy particle from space aliens, the SC7 command would abort with an “Unable to access that address” message when looking for valid PowerPC return addresses. I got hit with a really gooey particle (knocked me unconscious, too) and was lucky enough to get a reproducible case of this problem, so now it's fixed. 68K DEBUGSTR ------------ Due to a Ptr (generally signed char) vs. StringPtr (unsigned char) bug, the string that was passed to DebugStr was limited to 127 characters. If the string was longer, nothing would be displayed. This is no longer the case; DebugStr strings can now be up to 255 characters long. When running in 24-bit mode on a 32-bit capable machine, if the pointer to the DebugStr string had any bits set in the high byte, MacsBug could bus error when trying to display the string. This has been fixed. A-TRAP BREAKS ------------- When VM was on, and you attempted to break on a selector-based trap whose selector value was on the stack, we looked on the wrong stack for the value. Obviously, this greatly reduced the chances that we'd actually break when you expected it to. 68K DISASSEMBLY --------------- When disassembling a PACK A-Trap, we now display the name of the package in the comment field of the disassembly. MEMORY SETTING AND DISPLAY -------------------------- When you use any of the Set Memory commands (“SM”, “SL”, etc.), the underlying processor cache is now flushed over the range just set. This means you can now reliably modify code and then execute it. A new basic type has been added to those used in templates. IOREFNUM supports the display of the file name associated with a given refNum, as well as the open fork ([data] or [rsrc]). For example, if you use the “iopb” template, the output of the ioRefNum field used to look like this: 008C0E40 ioRefNum 0D98 but now looks like this: 008C0E40 ioRefNum 0D98 = MacsBug Release [data] Changed the “DM” (Display Memory) command so that it uses ditto marks for groups of identical lines when dittoing has been enabled with “SET DITTO ON”. The “DMA” (Display Memory ASCII) command can now accept very large byte counts. FILE DCMD --------- The short-form display (file 0) now omits the fields which have no use after-the-fact in a log file. LEAKS DCMD ---------- The various Memory Manager patches are now installed at dcmdSecondaryInit time so that we can detect leaks in PowerPC code (after the native Modern Memory Manager is loaded). MISCELLANEOUS ------------- MacsBug now knows how to hide the hardware cursor on machines that support it, such as the PCI boxes. The value of A7 shown by the “TD” (Total Display) command is now correct when running with VM enabled. It used to be the value of the ISP, when it should have been the USP. When any command reports a syntax error, a message is shown with the proper command syntax. Added a new SET sub-option, “SUSPENDPROMPT”. This works much like the “SCROLLPROMPT” option, but prompting is only disabled until the next line of command input is requested. BUILT-IN DEBUGGER PREFS ----------------------- The standard log macro (StdLog) has been enhanced somewhat. It now uses “HC” with the “ALL” option, so it won't abort if a heap is corrupt. The macro now records the value of the long at 0x00000000 so you can see if a piece of code was doing bad things. Changed some templates to use the new basic type IORefNum, where appropriate. Disk Init (PACK 2) actually takes its selector on the stack, not in D0. The glue moves it through D0, which seems kind of lame, if you ask me (this means we won't disassemble this without some special-case code which has yet to be written). Added selectors for SpeechRecognitionDispatch, PowerMgrDispatch selectors $22..$28, and ControlStripDispatch selectors new with Control Strip 1.2. • 6.5d12 - Released 4/13/95 HEAP SCRAMBLING --------------- When we move a block of data around, we can't tell if it contains executable code, so the processor caches should have been flushed on the destination range. In the past, when the entire cache was flushed very often, this wasn't a problem. With the cache flushing changes in 6.5d10, heap scrambling became very much unreliable. This has been fixed. POWERPC EMBEDDED SYMBOLS ------------------------ We now support looking up PowerPC embedded symbols from traceback tables. If you're using the newest Metrowerks 1.2.1 C/C++ compilers you can take advantage of this. The only other compiler I know that currently supports traceback tables is xlc for the RS/6000. With the current implementation, typing a symbol name will not evaluate to the address of that routine. The traceback symbols are currently only used within a disassembly of PowerPC code. CFM SYMBOL LOOKUP ----------------- When you're stepping through a fragment of PowerPC code that doesn't contain any exported CFM symbols (a simple application comes to mind), the delay between steps has been drastically reduced. This was done by removing a very large number of Mixed Mode switches on each line of disassembly, as well as fixing a logic bug that caused us to exhaustively look for 68K symbols when there couldn't possibly be any. WH COMMAND ---------- When displaying an address that is in VM file-mapped space, MacsBug now shows what CFM library the address resides within. STACK CRAWL ----------- MacsBug now understands Mixed Mode stacks when using the "SC7" command, and will show you the instruction set of each caller. This command now works correctly from either PowerPC or 68K code. For this release the "SC6" command works exactly as it did in 6.5d11 due to a last-minute problem (infinite recursion sucks). It will fully understand Mixed Mode stacks in the next release. POWERPC DEBUGGING ----------------- • When stepping up to a flow of control instruction, MacsBug displays a message which indicates if the branch will or will not be taken. In previous versions this was frequently wrong due to a sign-extension bug in the compiler, which we've worked around. • You can now disable PowerPC Debugger and DebugStr calls with the “DX” command. • The “TF” (Total Floating Point display) command now works when in PowerPC code, and will show the entire PowerPC native FPU register set. You can now use “FPR0” through “FPR31” in expressions, although this is totally useless since MacsBug's expression evaluation is centered around 32-bit values, and FPRs are 64-bit. • When displaying the PowerPC register set via “TD”, we now know about the 603e, and display a reasonable message for future processors. • When debugging PowerPC code at boot time, we no longer display the name of the currently loading extension after each and every step or trace. My, that was annoying. There are a few problems with native debugging that you should be aware of. They are: • If you're stopped on a native breakpoint, you currently can't Go, you need to Step once and then Go. • As above, if you're sitting at a branch to subroutine instruction that has a breakpoint located at it, you cannot Step Over the subroutine call without first removing the breakpoint. • If you use the single-machine Macintosh Debugger, or the Metrowerks Debugger which require the PowerMac Debug Services background application, you shouldn't place the app in the Startup Items folder. The app has a feature such that if it can't communicate with a host debugger, it will DebugStr into 68K code when it sees a native exception (breakpoint, trace, etc.). MacsBug will not get a chance to handle any native exceptions. If you do use a high-level debugger in cooperation with MacsBug, you should place the background application in the same folder as your debugger so it gets launched when you start up the debugger. RB AND RS --------- These commands no longer reboot if there are extra parameters on the command line. The motivation here is that Dave recently typed "rb -s" when he meant to type "rd -s", and he really, really didn't mean to reboot his system at that particular time. DCMD COMMAND ------------ We've added a new command which displays a compact list of all installed dcmds. This list includes the dcmd name and syntax, as well as the version if the dcmd is format 3 or later. The command can accept a optional prefix string to limit the display to a subset of all dcmds. RD DCMD ------- We've added a new option, "-h" which will show information on a resource given its handle. Very, very useful. When looking up resources by type, the "-t" option is now optional, so you can now type something like “RD 'STR '”. GESTALT DCMD ------------ A number of new selectors were added to the list of those that are recognized. THING DCMD ---------- The Thing dcmd is now a part of the standard MacsBug distribution. This dcmd displays information on Components. JUMPTABLE DCMD -------------- Fixed a stack imbalance problem that would cause MacsBug to exit when the dcmd was done executing. Why this had that sort of behavior and didn't crash is extremely odd. EXPRESSION EVALUATION --------------------- In the past there was no way to use the name of a trap in an expression and have it evaluate to the trap's number. Using the syntax “††<trapname>” now provides for this. For example, if you want to see what selector $18 off of trap HFSDispatch is, but you don't know the trap number, this expression will do the trick: dh 7018 ††HFSDispatch Of course, in this example you had to know that 7018 was MOVEQ #$18, D0 (everyone does, right?). With the addition of ROM map and Code Fragment Manager symbols in recent releases, the potential for confusion about exactly what symbol will be found if a name collision occurs has increased. If you know that a symbol you're trying to look up is ROM map-based, you've been able to prefix the symbol with the Option-R ('®') character. Now you can do a similar lookup order force for CFM. If your symbol string is prefixed with Option-G ('©'), it will be searched for first in the CFM name space. Since Option-G looks reasonable when displayed ('C' == CFM), but is a pain to remember, Option-C now maps to Option-G (try it, they're identical as far as MacsBug is concerned). We've added a really cool new feature we call “explain significance of”. During simple expression evaluation, we now show the magnitude of the resultant value in more human intelligible terms. In our daily trials debugging the System Software, we're quite often surprised at how many people can't look at a hex value and realize, “Oh, that's past the end of your logical RAM - that's why you died”. With this feature we hope for a greater awareness of the general magnitude of things. For example, typing the value $120C60 yields: 120C60 = $00120C60 #1182816 #1182816 '••`' (between 1M and 2M) For values that contain lots of trailing zeros, you'll get to see a new notation we've developed for more easily describing a 32-bit value. So that you don't have to call out each individual trailing zero (and look silly counting along on your fingers as you talk to your co-workers), we've developed the “kabillion” short-hand notation. For values that contain at least 5 trailing (least- significant) zeros, the notation will be used. For example, for $40800000, you get: 40800000 = $40800000 #1082130432 #1082130432 '@A••' (just over 1G; 4 0 8 kabillion) This is read “four-zero-eight kabillion” or “four-oh-eight kabillion”. Cool, huh? You can now use the Option-/ character ('÷') as an alias for '/' (division). MACROS ------ Macros can now optionally take parameters. When processing a macro expansion, positional parameters ®1 through ®9 represent the remaining whitespace-delimited tokens on the command line after the macro name. The parser understands the number of parameters your macro requires by noticing the highest-numbered parameter. If you use ®9 as a single parameter, you must have eight preceding parameters, which are ignored. These parameters can be quoted with single or double quotes, the quotes are not part of the parameter value. For example, the following macro takes a single parameter, a resource type. You would invoke this macro with a command line such as “gres 'gpch'”. "gres", "atb GetResource (sp+2)^='®1'" A sample parameterized macro is provided within MacsBug which will break on all 68K calls to GetResource, Get1Resource, and Get1xResource for a given type. This macro is named “RType” and is invoked as in the example above. When displaying macros with the “MCD” command, and the macro expansion needed two or more lines to be fully displayed, the text really should have wrapped instead of disappearing into the bit-bucket off the right side of the screen. Therefore, we now wrap the text appropriately. If you terminate this command before it finishes, you'll now get control back a lot faster. Since the evaluation of trap numbers in expressions has changed, if you want to find the trap name given a number but don't want to have to type “WH ††Axyz”, we've added a simple macro. The macro “WHT” shows the name and implementation address of a trap given a trap name or number. TEMPLATES --------- An extremely popular bug in template display has been fixed. When showing a region of memory with a template that contained a pointer field, and that field was filled was a garbage bus- error value, we'd quit showing the template when we reached that field. For example, doing “dm a0 iopb” with an ioNamePtr field pointing off into unmapped space no longer terminates the template display. MODERN MEMORY MANAGER HEAP STUFF -------------------------------- When identifying whether a heap is the Process Manager heap, we now only do this if the Process Manager is around (ie. it's after boot time). DISASSEMBLY ----------- When displaying the offset into a procedure, we now show 5 nibbles for the offset instead of 4. MISCELLANEOUS ------------- If you've invoked a command that displays a lot of output, and tire of having to press Return or Space to display another page, you can now temporarily turn off these prompts. Using Command- Return or Command-Space at the prompt skips the remaining prompts this command would have generated. You can still abort the command by pressing any key, you just won't be asked about it a bunch of times. When the command terminates, the prompts will be re-enabled for the next command (unless you've used the SET SCROLLPROMPT OFF to globally disable the feature). When we switch instruction set displays, we should now properly clean up all extra pixels in the register subdisplay. When you execute a command with too many parameters, MacsBug now displays a much more useful message, as well as actually showing you what parameters weren't needed. Command-G, -S, and -T now only work if the command line is empty. The TestDcmd application will now load format 3 dcmds, but doesn't do anything special to support them. The PlayMem general-purpose buffer is now always 4-byte aligned. BUILT-IN DEBUGGER PREFS ----------------------- We've added templates for the various SCSI Manager 4.3 API parameter blocks. • 6.5d11 - Released 2/27/95 POWERPC DEBUGGING ----------------- The support for PowerPC debugging has been greatly improved from that in 6.5d10, and is now much more like debugging 68K code. The following enhancements have been made: • MacsBug no longer handles all PowerPC trap or trace exceptions that are executed, it only catches those that it specifically caused, or the special Debugger/DebugStr trap. This fixes the popular incompatibility with the single-machine Power Mac Debug Services application. • The Debugger and DebugStr native traps are handled properly so that you won't repeatedly hit the trap instruction. You can now step up to and over these traps. Previously you had to manually set the PC past the trap to continue. DebugStr now shows the passed in string just like the 68K _DebugStr. • You can now trace over subroutine calls such as ‘bl’. • When you step up to a flow-of-control instruction, we now say whether the branch will be taken or not. • The PowerPC disassembler is now POWER-clean, and a lot smaller. • When disassembling PowerPC code that includes CFM exports, you'll no longer see the name of each procedure twice in succession. • Setting breakpoints should now be much more reliable. We now flush the appropriate PowerPC hardware cache lines when inserting and removing breakpoints. We used to be really stupid and flush the 68K cache, which didn't do anything useful. • We can now handle all native exceptions with VM enabled (we used to crash in a most spectacular way). • You can now set breakpoints in code that is file-mapped. PROCEDURE NAME DISPLAY ---------------------- When deciding if we should redisplay the name of the current procedure at the top line of the PC window area, we used to fail if the PC was located at 2 GB or above ($7FFFFFFF+). The thing you'd most-likely notice about this problem was the “Will branch/not branch” message would be drawn on top of the hex target branch address when stepping. MODERN MEMORY MANAGER HEAP STUFF -------------------------------- Previous versions of MacsBug were confused by the format of the Process Manager heap. If you'd “hx” to the heap, and then dump all relocatable and non-relocatable blocks, it thought they were all corrupt. When displaying the names of known heaps (System, Application, etc.), we now name the ROM read-only zone and the Process Manager heap. One place you'll see this is when you execute the “hz” command. BREAKPOINTS ----------- Due to the above heap problem, trying to set a breakpoint in a block that lived in the Process Manager heap was a hit or miss proposition, and sometimes you'd even get a bus error. Since MacsBug is no longer confused about the heap format, breakpoints there should now work reliably. A-TRAP TRACING -------------- The A-Trap trace mechanism has been enhanced to allow selective filtering of trap calls that get made at certain interrupt levels. When you're trying to find out why a piece of code crashed and you want to see the calling path, you can now see calls that are made with all interrupts enabled, for example. This can help filter out lots of noise and get you closer to the problem faster. When displaying each trap trace, the interrupt level at which the call was made is now shown. STACK CRAWL ----------- No, I didn't do mixed-mode crawls yet. They'll be in the next release. I promise. What I did do is make the “SC7” command work when you're in PowerPC code (it does a crawl based on register r1). It does the job just as poorly as when in 68K code, but it's still somewhat useful. CFM SYMBOL LOOKUP ----------------- We've sped up the process of lookup up CFM symbols quite a bit. The code that does this used to be 68K, so we'd take a mixed-mode switch on each symbol that we iterated over. The code is now native so we now take one switch on each lookup set, which is a tremendous reduction. You'll most notice this when you evaluate the name of a CFM symbol, such as “__NewPtr”. Native disassemblies may be a bit less jerky as well. ROM INFO SYMBOL FILES --------------------- When I introduced ROM symbol files in 6.5d10, I neglected to mention exactly where your ROMInfo/ROM map file should be placed. No matter what kind of file you're using, it must be located at the root level of your System folder. When loading ROMInfo files that contain unparseable text, the state machine used to identify the problem, but never did anything about it. It would then get stuck in a loop, and eventually would bus error. The error handling code has been improved quite a bit, and MacsBug now tells you near what character it ran into parse problems. Any symbols that were read up to that point will have been recorded properly. In the future, MacsBug will continue parsing until the end of the source file, in case there are more symbols after the point that it errored. FILL COMMAND ------------ We've added a new command, “FILL”, that allows you to fill large (or small) ranges of memory with a repeating long value. The range must be long-aligned and the count must be a multiple of four bytes. FILE DCMD --------- This dcmd now has a shorter display mode which skips showing all open font files. To use this shortened format, invoke the dcmd with a file reference number of zero (this is always a bad file reference number to the OS). The display looks much the same, except font files are ignored and a count of the number that was skipped is shown at the end of the list. RD DCMD ------- The RD dcmd also has a short-format display which ignores all open font files. To use this new feature, invoke the dcmd with the new “-s” option. When listing all maps in the current chain with either -s or -c, the output has been made to align a bit better, and we've added a new field. For each open file, we now show the map flags field right after the map handle. For any resource map that is overriding the System file (such as the active enabler), you'll now see a “+” in the leftmost column. For any resource that has been purged, we draw a “*” symbol to the right of the handle address. GESTALT DCMD ------------ We now skip the 'eajt' selector (Easy Access), because the first time you look it up, Easy Access tries to open a resource file to find the value, which hangs us. Hopefully we'll have a more general solution for this in the future. DCMD.H ------ The dcmd.h header file which is used to build dcmds in C now requires you to build with at least the 2.0a3 Universal Headers because ExceptionInformation has been changed to ExceptionInformationPowerPC. BUILT-IN MACROS --------------- The “StdLog” macro has been changed to use the shorter display options of the File and RD dcmds. This leaves out mostly-useless information (open font files), and shortens the bug log so that the chances are greater that it will fit in a bug report. The display of the stack crawl has been moved to the end of the macro so that if we're on a bad stack we'll get everything else logged before the stack crawl fails. There's a new macro named “ropen” which sets A-Trap breaks on all traps that open resource files. When a trap hits, the name of the file that was being opened is shown. This macro is really useful when you're tracing the system boot process, or debugging a 3rd-party application and would like to know what files get opened. MACSBUG'S SELF CHECKSUM ----------------------- In an effort to let you know when code has stomped upon MacsBug, it maintains a checksum of its code space. Each time you enter MacsBug this checksum is re-evaluated and compared to the original. If they differ, you will be alerted. However, due to some build changes way back in 1993, approximately 17K of the most critical part of MacsBug was being left out. This has been fixed. MISCELLANEOUS ------------- When you use the “WH” (“Where”) command to classify an address, MacsBug now does a better job telling you if the address is in not in RAM or ROM. Fixed the 8-bit low-level character blitter to not trash register A2. I said I did this in 6.5d9, but it was actually trashing it in two different places. This could cause problems with dcmds that use the drawing callbacks and expect A2 to be properly preserved. Made MacsBug work on the Mac Plus, SE, Portable and PowerBook 100 again. Our ROM family check was changed in 6.5d10 to better work a future OS, and it broke really old machines by making us think they were Mac II-class with Color QuickDraw. I don't think so. Fixed the Log command so that it fails if you don't specify a file name when using the “-h” option. Fixed ATSS to make the “addr” parameter required. It was never optional, but the command handler never enforced it. Corrected some mistakes in the 6.5d10 release notes. Please see change bars (“|” in the leftmost column) for deltas. BUILT-IN DEBUGGER PREFS ----------------------- Changes were made to various resources within the default debugger prefs which is part of the MacsBug file itself. They include: • Trap AA54 has a name, so it's now listed as TextServicesDispatch. • 6.5d10 - Released 12/16/94 MULTIPLE DEBUGGER PREFS FILES ----------------------------- We now support up to 32 debugger preferences files that can be named whatever you wish. MacsBug looks in a folder named “MacsBug Preferences” which must be located in the root of the System folder (in the future it may support the Preferences folder if there is a call for it). Selector trap names, macros, templates, and dcmds can be located in these files. Resources of type 'mxpr' (MacsBug prefs), 'mxbi' (MacsBug init), and 'mxbc' (MacsBug colors) must still be located in your "Debugger Prefs" file, which cannot be located in this new folder. If you place more than 32 files in this folder, MacsBug will only load resources from the first 32 and will warn you about this. BUILT-IN DEBUGGER PREFS ----------------------- Changes were made to various resources within the default debugger prefs which is part of the MacsBug file itself. It includes: • Added some missing selectors off of ScriptUtil and SoundDispatch • Fixed the AUXDispatch selector length so we actually disassemble these • Made the Gestalt dcmd part of the standard build • Added a template for the dcmdParmBlock (describes format 3 parm block) PERFORMANCE SPEEDUPS -------------------- MacsBug no longer flushes the entire processor cache(s) when entering and exiting. Any time we have need to maintain cache coherency (such as when we set a breakpoint in RAM), we do a local flush of the page(s) that contain the target addresses. With this change and the accidental flush bug fix described below, MacsBug should no longer be causing cache-related bugs to disappear when stepping, tracing, or handling A-trap actions. This should also contribute to an overall speedier feel on '040 CPUs. I fixed a really nasty typo in the procedure that sets MacsBug's A5 world as current. Someone rewrote it a while back (1991) and left the old code commented out in place. However, they commented out the procedure's RTS instruction as well. Unluckily, the code that we fell into was MacsBug's internal FlushCache routine which took no parameters, so we didn't crash (which would have forced someone to notice this a long time ago). By making this routine not fall into the flush code we've sped up a bunch of things to the point of being much less annoying to use. Things that are affected, in order of most visible to least: • Any time we use trace exceptions to enter (most-noticeable for Step Spy) To show myself how much faster this now is, I did some timings when booting my main MacsBug machine, a PowerBook Duo 280c. The results are quite impressive and show over a 5X speedup for this particular case. The test was to Step Spy a longword-aligned long location (this is handled as a fast special-case inside MacsBug) which would not change. Timings are in seconds from the time the first 'INIT' resource in the first extension was to be loaded to the time that the Process Manager is first executed. 16s - Normal boot with MacsBug 6.5d10 installed but not activated in any way. 71s - Step Spy enabled on 0x00000924 with MacsBug 6.5d10 (without flush bug). 376s - Step Spy enabled on 0x00000924 with MacsBug 6.5d9 (with flush bug). • When any A-Trap action of any sort (ATT, ATR, ATB, etc.) is pending • When we handle any PowerPC exception (includes stepping and tracing) • Within our SetTrapAddress skank-o-matic patch • Dcmds that walk the heap via the callback no longer flush on each block walked • Any callback a dcmd makes • Any time a dcmd is called to perform any action • Entering MacsBug via an NMI or any user-visible exception • When we handle a bus error (visible to user) while in MacsBug • When we do an ES or EA MacsBug is a bit faster when swapping or scrolling the screen on PowerPC machines. We used to use BlockMove to do this, but internally it uses the 'dcbz' instruction which causes an alignment exception when writing to non-cacheable space (like the screen). We now use a function that is functionally equivalent to BlockMove, but that does not use 'dcbz'. ROM MAP/ROM INFO SYMBOL FILES ----------------------------- We now support ROM map (old style) and ROMInfo (new-style) symbol files. Thanks to Cameron Esfahani for this way cool code (You da' man!). This means that during disassembly of ROM code you will see symbols for internal ROM routines, rather than just trap names. If in any expression a local symbol in your code collides with a ROM symbol, but you want to force the evaluation to match the ROM first, prefix the symbol name with the '®' (option-R) character. MacsBug currently looks for files of specific names for each machine. The name is chosen from the Gestalt 'mach' selector for the current machine. If a file name for your machine isn't found in MacsBug’s list, it tries to load a file named “ROMMap”. The list of supported files and the corresponding machine ID is: "MacPlusROM.map", // 4 "MacSEROM.map", // 5 "MacIIROM.map", // 6 "MacIIxROM.map", // 7 "MacIIcxROM.map", // 8 "MacSE030ROM.map", // 9 "MacPortableROM.map", // 10 "MacIIciROM.map", // 11 "MacIIfxROM.map", // 13 "MacClassicROM.map", // 17 "MacIIsiROM.map", // 18 "MacLCROM.map", // 19 "MacQuadra900ROM.map", // 20 "MacPowerBook170ROM.map", // 21 "MacQuadra700ROM.map", // 22 "MacClassicIIROM.map", // 23 "MacPowerBook100ROM.map", // 24 "MacPowerBook140ROM.map", // 25 "MacQuadra950ROM.map", // 26 "MacLCIIIROM.map", // 27 "MacPowerBookDuo210ROM.map", // 29 "MacCentris650ROM.map", // 30 "MacPowerBookDuo230ROM.map", // 32 "MacPowerBook180ROM.map", // 33 "MacPowerBook160ROM.map", // 34 "MacQuadra800ROM.map", // 35 "MacQuadra650ROM.map", // 36 "MacLCIIROM.map", // 37 "MacPowerBookDuo250ROM.map", // 38 "MacIIViROM.map", // 44 "MacPerforma600ROM.map", // 45 "MacIIVxROM.map", // 48 "MacColorClassicROM.map", // 49 "MacPowerBook165cROM.map", // 50 "MacCentris610ROM.map", // 52 "MacQuadra610ROM.map", // 53 "MacPowerBook145ROM.map", // 54 "MacLC520ROM.map", // 56 "MacQuadra660AVROM.map", // 60 "MacPerforma46xROM.map", // 62 "MacPowerBook180cROM.map", // 71 "MacPowerBookDuo270cROM.map", // 77 "MacQuadra840AVROM.map", // 78 "MacPerforma550ROM.map", // 80 "MacPowerBook165ROM.map", // 84 "MacLC475ROM.map", // 89 "MacQuadra605ROM.map", // 94 "MacPowerBookDuo280ROM.map", // 102 "MacPowerBookDuo280cROM.map" // 103 If, using the two above tries, MacsBug fails to load any map file, it tries to load the new-style “ROMInfo” file. For this style of file there presently is no machine name to machine ID mapping, since there is no officially maintained ROMInfo file collection as there is with the ROM map files (they are packaged with MPW on the E.T.O. developer CDs). DCMD CHANGES ------------ We now support a new style of dcmd, format 3. Most of the changes are designed to make it easier to add functionality to the dcmd callback and action interfaces in the future. Format 3 dcmds will not load on versions of MacsBug prior to 6.5d10. To build a format 3 dcmd, the BuildDcmd tool has been enhanced to take a format specifier option. If the '-format3' option is passed, the tool generates the new style dcmd. If no option is specified, the older style format 2 dcmd is generated. The only physical difference in the two formats is the embedded version word. All other differences are in the programming model MacsBug provides, and the requirements MacsBug makes on the dcmd. New dcmds are required to ignore action requests that they do not handle or recognize. This means that they must not display any sort of error if given an undefined action (no beeping!). The DcmdParmBlk structure has been extended with the MacsBug version, maximum supported callback number, current ISA, PowerPC exception structure pointer, and general-purpose I/O buffer pointer. The 68K RegisterPtr and PowerPC exception structures will only be valid if the respective pointers are non-nil. At present the structures will only be valid when the corresponding ISA is the current ISA. For example, if the current ISA is kM68KISA, then the 68K register set will be valid and the PowerPC information will not be valid. This may change in the future such that both register sets may be valid at the same time, so check for non-nilness rather than the associated ISA. Added a new action code, dcmdGetInfo, which returns dcmd version, usage string, and credits string. For format 3 dcmds this means that when given the dcmdHelp message, a dcmd should only draw the body of the text and no headers or usage information. MacsBug uses a combination of the dcmdGetInfo and dcmdHelp messages to display a more uniform help and usage. Added a new action call dcmdSecondaryInit which is called at a time when all System patches have been loaded (including native code on PowerPC), but is immediately before extension/INIT loading. This may only be guaranteed with 7.1, (7.1.1), 7.1.2, and 7.5. This is a good time to apply persistent global toolbox patches or record various state information before extensions or the Process Manager have a chance to muck things up. Added a new action call, dcmdShutdown, which is presently not used. It'll be more defined in a future release. POWERPC DEBUGGING ----------------- WARNING: The native disassembler included in this version is not POWER clean. It will execute illegal PowerPC instructions when disassembling a variety of opcodes on a 603 or 604 machine. This will be resolved by the next build. PowerPC debugging is enabled for the first time. With this build the support is quite rudimentary, however. A few new commands were added to support the PowerPC feature set. They are: ILP - Disassembles PowerPC instructions from a given address. IPP - Disassembles a half-page of PowerPC instructions centered on the given address. IDP - Disassembles 1 line of PowerPC instructions. DHP - Disassembles a sequence of 32-bit expressions as PowerPC instructions. GP - Propagates the PowerPC exception we last handled to the next exception handler registered with the system. BRP - Sets a breakpoint in PowerPC code (does not currently support breakpoints in ROM). The behavior of some commands have been enhanced to support PowerPC debugging. The changes that have been made thus far are: TD - When in PowerPC code, this displays the entire PowerPC register set. IL - When the current ISA is PowerPC, typing IL without an address (which implies the current PC), MacsBug will automatically disassemble the code as PowerPC. IP - When the current ISA is PowerPC, typing IP without an address (which implies the current PC), MacsBug will automatically disassemble the code as PowerPC. WH - If the address being examined is located within a CFM container, MacsBug will display the name of the fragment, along with the nearest exported symbol. MacsBug now understands all native PowerPC exception types when they occur, and will activate with the display formatted for debugging PowerPC code. For example, if native code causes a bus error, MacsBug will gain control and break into the code at the address of the faulting code, just like it does for 68K code. From there you can step, display and change registers, use dcmds, etc. Be aware that stepping and tracing in this release is extremely limited. You can only step one instruction at a time, and cannot step over any branch instructions (you'll always step into the branch call). Full PowerPC debugging will be available in a future release. | There currently isn't any way to step over Mixed Mode transitions from one ISA to another - you'll need to set a breakpoint on the other side of the transition and go until it is | hit. In the future MacsBug will be intelligent about this, and debugging the two instruction sets will be seamless. SYMBOL LOOKUP ------------- We now use the Code Fragment Manager to look up symbols when running on PowerPC machines. Many commands benefit from this, including but not limited to WH, DM, ILP, and DHP. SELECTOR-BASED TRAP NAMES ------------------------- The ATP command now displays actual selector names of calls that were made, as well as | the parent trap. The parent trap name is shown in parenthesis. LOGGING ------- Log files are now created by default on the root of the boot volume. The Log command now has a parameter, '-h'. This allows you to save your scrollback history from the beginning to the bottom of the current screen (if you've scrolled up into the history when you execute this, all lines off of the bottom of the screen will be lost, as with any other command). Thanks to Hoon Im for taking some time out to add these cool features way back for 6.5d9, but we forgot to tell you about them. | Note that the log file will remain open. You must execute the “log” command with no parameters | to close the file. RESTART/REBOOT COMMANDS ----------------------- RS and RB commands should now work on the Mac Plus, and more importantly, they should once again work on all future machines. Both of these commands now use the Shutdown Manager (ShutDwnStart) if it is deemed necessary. However, they will not run any items that have been queued with ShutDwnInstall on the premise that your machine is probably already hosed and running a high-level shutdown proc probably wouldn't be a good idea at this point. PCI BUS DISPLAY SUPPORT ----------------------- The video initialization and control code was rewritten to support the new PCI machines. Since these machines no longer have NuBus-style declaration ROMs, we now use new video driver calls to obtain information we previously used the Slot Manager for (getting base addresses, bit depths, etc.). If the new calls fail (as they will on non-PCI machines at present), we drop back to using the Slot Manager. MEMORY USAGE AND ERROR REPORTING -------------------------------- Throughout MacsBug's initialization code, we now follow the boot code rules in regards to how much memory can be allocated from BufPtr. If we cannot at least get our stack and video buffer, we will refuse to load. If we can't load other non critical resources and preferences, we'll load, but we'll show a message indicating a memory allocation problem when you first enter the debugger. If MacsBug refuses to load, for whatever reason, it will display an error message in place of the “Debugger loaded” message on the “Welcome to Macintosh” startup screen. MacsBug's internal stack is now always 10K in size, which is up from 4K. This was added to stop some stack overflows we were seeing with the new PowerPC features. However, this will benefit dcmds as well since they normally use MacsBug's stack. MISCELLANEOUS ------------- The HOW command can now display the name of the currently loading extension in the same manner that is automatically done when you enter MacsBug at boot time. This is useful for bug log reports since this command is already part of the StdLog macro. When dumping the MMU state on an '030 or '851, the "PSR" register is no longer incorrectly called "SR". • 6.5d9 - TOTALLY NEW STUFF ----------------- Added the DMA command (dump memory in ASCII). The syntax is just like DM. Added .S suffix ("strip"). For example, PC.S is the same as PC if you are in 32-bit MMU mode, or (PC & 0x00FFFFFF) if you are in 24-bit MMU mode. MacsBug actually calls the StripAddress trap to implement this. ENHANCEMENTS ------------ When you break into MacsBug at boot time by holding down the Control key, now it shows a more enlightening message. Hopefully this will stop people from writing up bugs that say "I rebooted with the control key held down, and I got a User Break!" When you break into MacsBug during boot, it displays the name of the currently- loading extension, if any. Command lines consisting only of "G", "T", or "S" do not appear in the command line history (Command-V / Command-B). The side-effect is that Command-G, -S, and -T do not enter anything into the command line history. The SET command now displays its syntax if you tell it something stupid. "HZ" shows "Mod" for Modern Memory Manager heaps (it used to say "Fig"). The "WH" command, and others, can determine that an address is "inside MacsBug". The "DV" command includes some credits. "dv v" shows just the version, with no credits. MacsBug gets its version from its 'vers' 1 resource. The CurApName display uses an ellipsis character to truncate long names, rather than an underscore. Added an 8-bit-deep blitter (speeds up display on video cards that cannot switch to 1-bit mode). Made the one-bit blitter faster, too. Made scrolling up and down faster for all bit depths. MACROS ------ Changed the maximum command line length to 250 (was around 90 before). So now you can have very long macro expansions. Added a macro called "StdLog" (standard log), which is great for writing up bug reports. It creates a log file full of info that system software engineers like (stack crawls, register dump, configuration info, etc). Lots of random cleanups of the macros. Removed redundant macros. Changed "da" and "dd" macros to "DApp" and "DDrvr", because "da" and "dd" are valid hex numbers. DISASSEMBLY ----------- Trap vector names now show up in disassembly (and elsewhere) just as if you had a macro mapping into every address in the trap dispatch table. For example, MOVEA.L $06F4,A0 now disassembles as MOVEA.L jCacheFlush,A0. The trap is vCacheFlush, but the "v" (for vector) gets automatically changed to a "j" (for jump). The forms JSR ([$xxxx]) and JSR ([$xxxx],$yyyy) now support macro-style symbols for the $xxxx values. (Of course, do NOT use trap-table addresses in application code, but when you come across the system doing so, it's much easier to see what's going on now.) Fixed bugs in selector comparison (it was not always sign extending correctly). Disassembly now recognizes a CLR.W before a trap word as setting up selector with value zero. The PC disassembly window refreshes when you change D0-D7, A0-A7, SR, or PC. It was only refreshing on PC changes, but the others also affect the disassembly, because of symbolic info on JSR (Ax), "will branch" messages, and "will loop" (DBxx) messages. TRAP NAMES ---------- Generally brought tons of traps and selectors up to date and made them better. Updated PowerMgrDispatch stuff to match WWDC 94 Technology CD document. However, MacsBug can't handle the different variants of OS-range traps having different names and different selectors, so the $A085 trap disassembles strangely. The $A685 (PowerMgrDispatch) stuff is all there, but it (incorrectly) shows up for all variants ($A085, $A285, $A485, as well as $A685). DCMDS ----- Several commands now draw bullet characters in place of all control characters in strings (affects 'file' showing Return characters in filenames, for example). Gestalt command dumps all Gestalt selectors. Supports System 7.5 Gestalt table format as well as older versions. The 'rd' command now shows an asterisk after any handle that has been purged. It also accepts capital letters for the options. BUG FIXES --------- Fixed some random memory accesses that were happening on non-Color QuickDraw machines during MacsBug startup. This was causing the mouse to freeze in one or two directions on a Mac Plus. Fixed trashing of D3 and A2 in BlitCharOneBit and BlitCharEightBits. Changed PBControlSync to PBStatusSync because we were trying to do a cscGetMode instead of a cscSetMode. (Affects compatibility with certain video drivers.) • 6.5d8 TOTALLY NEW STUFF ----------------- Over the last few releases, we've worked to make MacsBug a bit more user- configurable and customizable. However, these configuration options have thus far been limited to setting bits in a preference resource, which doesn't allow for many on-the-fly changes. We've added a new general-purpose command that will enable behaviour changes any time you wish. The new command, SET, will be able to take a variety of options. The first is the new "ScrollPrompt" feature. By entering a command such as, "SET SCROLLPROMPT OFF", MacsBug can be told to never wait for a key if a new page of the scrollback history has become filled. Other variants of the new command are shown in the built-in help. In the future you'll find lots of other cool things you'll be able to do. There's now a 512-byte scratch memory area within MacsBug that's available for whatever you like. It's called "PlayMem" (TMON user's will recognize this), and can be used within any expression. The constant will evaluate to the address of the beginning of the buffer area. A-TRAP DISASSEMBLY ------------------ Removed bogus duplicate A-trap name for StdOpcodeProc (it's really $ABF8; it was also in the table as $ABC8). Fixed vFileReal to be vFileRead. Unused/unknown A-traps now disassemble as "DC.W $Axyz" instead of "TB z" or "OS z". Lots of new names have been added to previously existing selectors, but they are too numerous to go into here. All calls have been updated to the more verbose new Inside Macintosh naming conventions. All old versions still work through the magic of macros. Disassembling selector-based calls is now much smarter when it comes to identifying the correct call. When it looks back up the code stream to identify the selector value, it is more knowledgeable about the various MOVE immediate instructions. It no longer unhelpfully interprets random data as selector values. A-TRAP TRACING -------------- It now correctly works again (no more _Open calls). It'll be more verbose in the future, but at least it now does what it did before. A-TRAP RECORDING ---------------- Versions of MacsBug from 6.4 through 6.5d6 had a serious bug that appeared during A-Trap recording. When recording OS calls, we save the first 8 bytes pointed to by register A0, for display by the 'ATP' command. In the instances that A0 isn't an input parameter to the trap, and contains an invalid pointer (outside of valid memory on the target machine), MacsBug takes the precaution of installing a special bus error handler when it attempts to copy the data. However, previous versions improperly installed the handler (they hooked on top of two vectors, both of which were wrong). Thus, if a bus error occurred during the copy, MacsBug's primary handler would take control and display the error to the user, which was completely the wrong thing to do. HEAP DUMPS ---------- When MacsBug dumps heaps that contain resources from open files, it is more careful in showing the error, "** bad rsrc map**". SCROLLBACK HISTORY ------------------ The supported sizes of the scrollback history buffer have been changed to allow for a much larger buffer. Previously, only values of 0-32767 were supported, which specified the requested history buffer size in bytes. 0 and 1-255 indicated that no history buffer should be allocated at all. Now values of 32768-65535 are valid, and 1-255 indicate special larger sizes. For 1-255, the value is multiplied by 64K, giving a range of 64K-16MB in 64K increments. Zero is still supported to allocate no buffer. (Page Up/Down mostly work, but there are still a few problems.) SYMBOL LOOKUP ------------- If we break into MacsBug with VM enabled and paging isn't safe, we now act as though symbol display is turned off (via the "SX" command). Doing symbol lookups causes heaps throughout memory to be walked, possibly causing quite a bit of paging to take place. This is an extremely evil thing for a low-level debugger to do, and we're trying to be as nice as we possibly can. COMMAND-: SYMBOL LOOKUP ----------------------- Fixed the infamous C++ unmangled symbols problem. MacsBug would show you the symbol in the Command-: window, but it wouldn't evaluate it unless you stripped the quotes from the unmangled name. This is no longer necessary. If you hold down the Option key when pressing return after selecting a symbol, the address of the symbol is entered onto the command line, rather than the symbol itself. However, if you navigate the list by typing and use this feature, it used to dump a semi-random address. This has been fixed. MEMORY DISPLAY -------------- When displaying addresses that correspond to bus error vectors (0x00000008 through 0x0000000B and VBR+0x00000008 through VBR+0x0000000B), we now show the previous vector addresses, not the MacsBug handlers. This should make it a bit easier to find your code if you replace either bus error vector. The built-in font now contains the entire high-ASCII character set for a more useful display ($20 through $D9). You can now type all of these characters as well. Template related code has been fixed to not cause address errors on 68000 machines. STACK CRAWL ----------- When determining if a given address is really a return address as we walk up the stack, we no longer cause page faults. This should make the stack crawl commands a bit more useful when used in an environment where VM paging is not safe. BREAKPOINTS ----------- If you set or clear a breakpoint, the disassembly display area above the command line will be redrawn, in case there's an upcoming break that's already been called out with a bullet alongside an address. REGISTERS --------- Code dealing with setting and displaying the Status Register now realizes it is 16-bits in length and always has been. This bug has been present since at least 6.2. LOGGING ------- If you attempt to turn the log on or off when the file system is busy, MacsBug will warn you that this is impossible. This helps a bit in preventing data on your drives from being corrupted, but there's still a huge architectural flaw in the whole thing (ask me about my 400 MB I had to restore from tape...). In a nutshell, it works, but just barely. MISCELLANEOUS ------------- Keyboard repeat rates have been fixed for the Mac Plus (it no longer spews tens of keys for each individual keypress). DCMDS ----- RD - The help explains what the various attributes flags are. Map $0003 shows up with a special name now, instead of garbage (it makes ROM resources override the system). The command aborts much faster now if you press a key. Fixed problems of excess filtering when you used -f along with -t or -i (or when you used -i at all). • 6.5d7 - NOTE: This version sorta-kinda exists. It was released to a small number of individuals related to the System 7.5 and PowerPC v0 teams, but it was never generally released. There are actually a few different versions of d7, so it was decided the best thing to do was say, "don't use it - use 6.5d8 instead". • 6.5d6 - HEAP SCRAMBLING --------------- It works again, what more can I say? Starting with MacsBug 6.5d1 (before I took over the project), the Heap Scramble command was broken for all Memory Managers, including 24-bit, 32-bit, and Modern. It now works properly for the classic Memory Managers, and for the first time, is works equally well for Modern-style blocks and heaps. If you break into MacsBug because of a Heap Scramble failure, the proper tool name will be displayed. It used to try to display the names of selector-based tools, but failed, since we only scramble on a few real A-Traps. All you would see is a bunch of gunk, but no harm was done. EXCEPTION HANDLER ----------------- While you're sitting at the command line, MacsBug has its own bus error handler installed. If something goes wrong, you'll generally see the message "Unable to access that address". However, if the exception was generated by code within MacsBug, finding the code that actually caused the exception was quite difficult. Now MacsBug displays some simple diagnostic information, including the Program Counter of the code that really caused the exception. • 6.5d5 - With the addition of "User Debugger Prefs" there's been a lot of confusion. So, in an effort to reduce this, and make absolutely sure each version of MacsBug has available the resources it needs to run, "User Debugger Prefs" is no longer supported, and the Debugger Prefs resources now exist within MacsBug itself (that's why it's now almost 400K on disk). All custom resources should go into Debugger Prefs, and MacsBug's resources should be left alone. - We now check for duplicate dcmds at startup and display their names. You'll see this list (if you have any duplicates) the first time you enter MacsBug. - Increased the number of words that DH can disassemble at once from 6 to 18. - Fixed a minor bug with A-Trap actions. If you had an action set on any selector, removed it, and then did an 'ATSS', 'ATB', or 'ATHC' with no parameters, the range start would appear to be the old selector. We were setting the selector flag and value fields in the trap record if the selector was specifically described, and we weren't clearing them otherwise. Since the new action record was in the location of the old record, the uninitialized fields were used. - When an A-Trap Trace is displayed, we now show the name of the selector instead of its parent A-Trap, if necessary. This means if you do an 'ATT' on _GetFrontProcess, for instance, when the trace information is dumped into the MacsBug history, the trap name will be _GetFrontProcess instead of its parent, _OSDispatch. - When you break into MacsBug because of an A-Trap action on a selector- based call, the selector name will be displayed instead of the parent A-Trap name. - We now mostly work on 68000 machines (again). If the trap name STR# resources were an odd length, we'd address error at startup while trying to load them. We now pad them in memory to be word-aligned, just like all of our other structures (would you belive I solved this one with MicroBug?) - Updated the TestDcmd application: -Made the font draw like they do Macsbug (you get space through ~, plus ≈ and † and … and •, and everything else is a bullet). -Made Command-G = Command-Q. -Made ? = help. -When the screen is paused, still proccess events except for non-Command keypresses. -Made space continue as well as return/enter. -Made Clear/Ctrl-X clear the command line. - In the 'file' dcmd, made some columns wider and fixed the filename-prefix feature. - In the 'drvr' dcmd, widened the driver name field so you can see longer names without truncation. • 6.5d4 - Fixed command line history to not get confused when you repeat a previous command with Command-V or Command-B. It wasn't resetting the history marker when you entered a new command that exactly matched the last command, so you could only repeat the last command once, and then the last command would become the line prior to that. - Fixed a nasty bug dealing with most break action commands. If you set more than one A-Trap break, A-Trap Step Spy, or Breakpoint, each new break would overwrite the previous, corrupting it. The record that could become the most damaged was that of the Step Spy, which could cause MacsBug to become way confused the next time it walked the table. Almost not broken just isn't good enough for me! - Breaking on selector-based calls now works! If you want to break on one of these calls, ATB (and all of its variants) now use the same structures that provided for the disassembly of selector-based calls. I've slightly modifed the displays for the ATB and ATD commands to account for the fact that you're not necessarially breaking on all calls of a specific ATrap. It now shows you both the selector name and ATrap name, plus the ATrap and selector values. The way that this works is cool enough that you can still provide a conditional break expression which allows for even more fine-tuning of when to break. So something like, "ATB _GetFrontProcess D0.w=-1" will work, even though in most cases it's not really that useful, since in this case it's already implicitly breaking on the expression "(SP)^.w=39". If there are calls that you can't seem to break on, there are a number of reasons why. The most-likely is that I simply haven't yet added calls of that particular A-Trap to the prefs file (although it could be there and I simply screwed up the selector). - Because of the above, I've removed lots of redundant macros from the Debugger Prefs file (the ones that did the "ATB _CallName d0.w=#x"). - MacsBug now supports a new preference resource (which can be located in either the User or standard Debugger Prefs file) of type 'mxpr'. Its sole purpose in life right now is to support some cool power-user "danger prefs" that support doing things a bit faster. There's a ResEdit TMPL provided in Debugger Prefs which allows you to edit the various defined bits. I recommend copying it into your User Debugger Prefs file (since that's why I added the file anyway) and changing it there. I'll probably eventually add new commands to MacsBug itself that let you modify the more useful preferences at run-time. - Two preferences bits support disabling the little-known self-checksum feature. Normally, after you execute any command from the command-line, MacsBug performs a checksum on all of its code, and warns you if it was modified. While this can be quite useful, most will never see the message. The annoying bit is that this takes a heck of a lot of time (MacsBug's code is about 100K in memory right now, so on my analyzer-bait Mac II the checksum takes 151.1ms). Now you can selectively disable the checksum in all cases by setting the "Never checksum MacsBug code" bit. If you'd like some assurances that MacsBug wasn't stomped on, you can set the "Only checksum code on entry" bit. When you enter MacsBug, either through a DebugStr or Debugger trap or via an NMI, it will perform the checksum. Note that the "never" bit overrides the setting of this bit. - One other bit has quite a noticeable effect on stepping and tracing with a machine that has a single monitor (or one that has MacsBug on its main device). This bit, "Don't swap screen if stepping", does just what it says. If you step with this bit set, MacsBug will never swap the display to show the original video buffer. This is slightly dangerous if you're stepping code that does draw directly to the screen (because the video card could have been in an entirely different mode than what it is when you're in MacsBug). However, it will have no effect if you trace over a QuickDraw trap, because the display _will_ be swapped in that case. Use this, it's waaaaay cool. And faster too. - Added macros for GSBug users (me) who just can't seem to type the right commands while in MacsBug. STB now works for ATB, CTB now works for ATC, and SH works for ATD (actually, these were added in 6.5d2, but I neglected to mention it then). - Twiddled the message for MCC when a macro is cleared. It now says, "Macro '<macroname>' cleared" instead of "'<macroname>' cleared. Dave freaked for a second when he typed "MCC heap", and MacsBug responded with "Heap cleared". :-) - Modified the 'vbl' dcmd to use uppercase in hex displays (we're picky people). It now dumps all of the non-empty slot VBL queues in addition to the standard queue. • 6.5d3 - Modified to load selector traps, macros, templates, and DCMDs from two files. We still load from Debugger Prefs, however, we now support a new file, "User Debugger Prefs". This allows you to paste all of your custom resources into the User file, and not worry about having to copy resources when you upgrade the standard DP file. We also now allow 'mxbi', 'mxbc' and 'KCHR' resources to be found in the User file to override the default ones we ship in the DP file. This change causes all of the above mentioned resources to be loaded in the opposite order that they were in previous versions (all types of resources are now loaded increasing from index 1). - The Clear key and Control-X now clear the entire command line and move the cursor to the left edge. - The key delay to repeat and repeat rate have been (hopefully) equalized for all machines. No more annoying slowness on fast machines. - Sped up the one-bit single character blitter to be as fast as it was in 6.2.2. The overall string drawing throughput is slower than 6.2.2, but it'll probably get faster in later versions. As compared to 6.5d2, however, the blitter is 6.3 times faster, which is quite cool. • 6.5d2 - Added a new resource type, 'mxst', to Debugger Prefs for the display of toolcall names that are selector-based (ie. HFSDispatch). This allows you to see the names of the real calls, rather than simply the dispatch trap name. Eventually you'll be able to break on the names, instead of having to define macros like you do now. I added a bunch of toolcall names to Debugger Prefs, but there are certainly some missing, and there may be some that are incorrect. • 6.5d1 - Moved toolbox and OS trapnames into STR# resources in the Debugger Prefs file. Added initial support for the Modern Memory Manager. • 6.4a9 - Fix breakpoints in ROM to actually break. - Fix to not mess with the interupt levels if we enter MacsBug in user mode. • 6.4a8 - Fix problem with the calculation of video slot address causing some machines to not boot. - Remove indication of bit depth from MacsBug screen. This bit depth was indicating what the depth MacsBug was operating in not the depth of the monitor when running normally. • 6.4a7 - Support for multibit video.